//==========线程池的使用=============
#include <iostream>
#include "ThreadPool.hpp"

int main() 
{
    ThreadPool mypool(4);
    for(size_t i = 0 ; i < 20; ++i) 
    {
        auto rsfuture0 = mypool.enques([](int a,int b)->int{
                std::cout <<"当前线程："<<std::this_thread::get_id() <<std::endl;
                return a+b;
                },10*i,10*i);
        std::cout <<"thread rs:"<< rsfuture0.get() << std::endl;
    }
    return 0;
}


//=================指针指针===============
//1.shared_ptr
//#include <iostream>
//#include <memory>
//#include <string>
//class Test 
//{
//public:
//    Test() 
//    {
//        std::cout <<"构造函数"<<std::endl;
//    }
//    Test(const int& x)
//        :m_num(x) 
//    {
//        std::cout <<"构造函数 x" <<std::endl;
//    }
//    Test(const std::string& str) 
//    {
//        std::cout <<"构造函数 string" <<std::endl;
//    }
//    ~Test() 
//    {
//        std::cout <<"析构函数"<<std::endl;
//    }
//    void setValue(int v) 
//    {
//        m_num = v;
//    }
//    void print() 
//    {
//        std::cout <<"m_num:"<< m_num <<std::endl;
//    }
//private:
//    int m_num;
//};
//int main() 
//{
//    //通过构造函数初始化
//    std::shared_ptr<int> ptr1(new int(3));
//    std::cout <<"ptr1:"<< ptr1.use_count() <<std::endl;
//    //通过移动构造和拷贝构造初始化
//    std::shared_ptr<int> ptr2 = std::move(ptr1);
//    std::cout <<"ptr1:"<< ptr1.use_count() <<std::endl;
//    std::cout <<"ptr2:"<< ptr2.use_count() <<std::endl;
//
//    std::shared_ptr<int> ptr3 = ptr2;
//    std::cout <<"ptr2:"<< ptr2.use_count() <<std::endl;
//    std::cout <<"ptr3:"<< ptr3.use_count() <<std::endl;
//
//    //通过std::make_shared 初始化
//    std::shared_ptr<int> ptr4 = std::make_shared<int>(8);  //开一个int并初始化为8
//    std::shared_ptr<Test> ptr5 = std::make_shared<Test>(5);
//    std::shared_ptr<Test> ptr6 = std::make_shared<Test>("hello world");
//    //通过reset初始化,重置指针引用计数变成0
//    ptr6.reset();
//    std::cout <<"ptr6" << ptr6.use_count() <<std::endl;
//    ptr5.reset(new Test("hello"));
//    std::cout <<"ptr5" << ptr5.use_count() <<std::endl;
//    //获取原始指针
//    Test* t = ptr5.get();//对象里面用.拿到里面的api函数，拿到这个指针
//    t->setValue(1000);
//    t->print();
//    std::cout <<"通过智能指针直接进行操作"<<std::endl;
//    ptr5->setValue(200);
//    ptr5->print();
//
//
//    std::shared_ptr<Test> ppp(new Test(100),[](Test* t){
//            std::cout <<"------------" <<std::endl;
//            delete t;
//            });
//    return 0;
//}
//
//=============转移move和完美转发forward==========
//===========右值引用==============
//#include <iostream>
//#include <list>
//class Test 
//{
//public:
//    Test()
//        :m_num(new int(100))
//    {
//        std::cout << "conststruct:my name is jerry" << std::endl;
//        printf("m_num地址:%p\n",m_num);
//    }
//    Test(const Test& a)
//        :m_num(new int(*a.m_num))  //主动提供了拷贝构造编译器不会主动生成默认的拷贝构造函数
//    {
//        std::cout <<"copy struct:my name is tom" <<std::endl;
//    }
//    //引动构造函数 -> 堆内存m_num,浅拷贝
//    Test(Test&& a)
//        :m_num(a.m_num)
//    {
//        a.m_num = nullptr;
//        std::cout <<"mov struct" << std::endl;
//    }
//    ~Test() 
//    {
//        std::cout << "delete..." << std::endl;
//        delete m_num;
//    }
//    int* getNum() const
//    {
//        return m_num;
//    }
//private: 
//    int* m_num;
//};
//Test getObj() 
//{
//    Test t;
//    return t;
//}
//int main() 
//{
//    Test t = getObj();//如果是临时对象就调用移动构造函数，不是临时对象就调用拷贝构造
//    std::cout <<std::endl;
//    Test && t1 = getObj();
//    Test&& t2 = std::move(t1);
//    printf("m_num地址：%p\n",t1.getNum());
//    return 0;
//}
//#include <iostream>
//int main() 
//{
//    //左值
//    int num =  9;
//    //左值引用
//    int& a = num;
//    //右值
//    //右值引用
//    int&& b = 8;
//    //常量左值引用
//    const int& c = b; //c是num的别名
//    //常量右值引用
//    const int&& d = 6;
//    //const int&& d = b;//error
//    // int&& d = b;//errori 说明右值引用只能通过右值进行初始化 
//    return 0;
//}

//#include "ThreadPool.hpp"
//std::unique_ptr,独占所有权，不能共享
//std::shared_ptr，共享所有权，引用计数管理
//std::weak_ptr，与 std::shared_ptr 搭配使用，解决循环引用问题

//============ lambda表达式=========
//[选项](参数列表) opt->ret {body};// 返回值可以后置
//[捕捉方式]
//捕获外部变量的 Lambda 表达式不能直接转换为普通函数指针。
//不捕获外部变量的 Lambda 表达式可以转换为普通函数指针，但要注意代码的语法正确性，如语句结尾的分号等。
//#include <functional>
//#include <iostream>
//void func(int x, int y) 
//{
//   int a = 9;
//   int b = 7;
//   using ptr = void(*)(int);
//   ptr p1 =  [=,&x](int z)mutable //可以对只读的变量进行++操作
//   {
//       int c = a;
//       int d = x;
//       b++;
//       std::cout<<"我是lambda的：" << b << std::endl;
//   }(88);  //只是定义没有调用,加个()就是调用
//    p1(11);
//    ptr p2 = [](int x)
//    {
//        std::cout <<"x:" <<x <<std::endl;
//    }
//int main() 
//{
//    func(1,2);
//    return 0;
//}

//int add(int a, int b) 
//{
//    return a + b;
//}
//int main() 
//{
//    //使用std::function 包装普通函数
//    std::function<int(int,int)> func = add;
//    std::cout << func(3,4) << std::endl;
//
//    std::cout << "lambda表达式" << std::endl;
//    std::function<int(int,int)> lambfunc = [](int a, int b) {return a * b;};
//    std::cout << lambfunc(10,12) <<std::endl;
//    return 0;
//}
